﻿
#region Using directives

using System;
using System.Collections;
using System.Collections.Specialized;


using System.Web.Configuration;
using System.Data;
using System.Data.Common;
using System.Configuration.Provider;

using Microsoft.Practices.EnterpriseLibrary.Data;
using Microsoft.Practices.EnterpriseLibrary.Data.Sql;

using GPSTrackingDBV2.Entities;
using GPSTrackingDBV2.Data;
using GPSTrackingDBV2.Data.Bases;

#endregion

namespace GPSTrackingDBV2.Data.SqlClient
{
	/// <summary>
	/// This class is the Sql implementation of the NetTiersProvider.
	/// </summary>
	public sealed class SqlNetTiersProvider : GPSTrackingDBV2.Data.Bases.NetTiersProvider
	{
		private static object syncRoot = new Object();
		private string _applicationName;
        private string _connectionString;
        private bool _useStoredProcedure;
        string _providerInvariantName;
		
		/// <summary>
		/// Initializes a new instance of the <see cref="SqlNetTiersProvider"/> class.
		///</summary>
		public SqlNetTiersProvider()
		{	
		}		
		
		/// <summary>
        /// Initializes the provider.
        /// </summary>
        /// <param name="name">The friendly name of the provider.</param>
        /// <param name="config">A collection of the name/value pairs representing the provider-specific attributes specified in the configuration for this provider.</param>
        /// <exception cref="T:System.ArgumentNullException">The name of the provider is null.</exception>
        /// <exception cref="T:System.InvalidOperationException">An attempt is made to call <see cref="M:System.Configuration.Provider.ProviderBase.Initialize(System.String,System.Collections.Specialized.NameValueCollection)"></see> on a provider after the provider has already been initialized.</exception>
        /// <exception cref="T:System.ArgumentException">The name of the provider has a length of zero.</exception>
		public override void Initialize(string name, NameValueCollection config)
        {
            // Verify that config isn't null
            if (config == null)
            {
                throw new ArgumentNullException("config");
            }

            // Assign the provider a default name if it doesn't have one
            if (String.IsNullOrEmpty(name))
            {
                name = "SqlNetTiersProvider";
            }

            // Add a default "description" attribute to config if the
            // attribute doesn't exist or is empty
            if (string.IsNullOrEmpty(config["description"]))
            {
                config.Remove("description");
                config.Add("description", "NetTiers Sql provider");
            }

            // Call the base class's Initialize method
            base.Initialize(name, config);

            // Initialize _applicationName
            _applicationName = config["applicationName"];

            if (string.IsNullOrEmpty(_applicationName))
            {
                _applicationName = "/";
            }
            config.Remove("applicationName");


            #region "Initialize UseStoredProcedure"
            string storedProcedure  = config["useStoredProcedure"];
           	if (string.IsNullOrEmpty(storedProcedure))
            {
                throw new ProviderException("Empty or missing useStoredProcedure");
            }
            this._useStoredProcedure = Convert.ToBoolean(config["useStoredProcedure"]);
            config.Remove("useStoredProcedure");
            #endregion

			#region ConnectionString

			// Initialize _connectionString
			_connectionString = config["connectionString"];
			config.Remove("connectionString");

			string connect = config["connectionStringName"];
			config.Remove("connectionStringName");

			if ( String.IsNullOrEmpty(_connectionString) )
			{
				if ( String.IsNullOrEmpty(connect) )
				{
					throw new ProviderException("Empty or missing connectionStringName");
				}

				if ( DataRepository.ConnectionStrings[connect] == null )
				{
					throw new ProviderException("Missing connection string");
				}

				_connectionString = DataRepository.ConnectionStrings[connect].ConnectionString;
			}

            if ( String.IsNullOrEmpty(_connectionString) )
            {
                throw new ProviderException("Empty connection string");
			}

			#endregion
            
             #region "_providerInvariantName"

            // initialize _providerInvariantName
            this._providerInvariantName = config["providerInvariantName"];

            if (String.IsNullOrEmpty(_providerInvariantName))
            {
                throw new ProviderException("Empty or missing providerInvariantName");
            }
            config.Remove("providerInvariantName");

            #endregion

        }
		
		/// <summary>
		/// Creates a new <see cref="TransactionManager"/> instance from the current datasource.
		/// </summary>
		/// <returns></returns>
		public override TransactionManager CreateTransaction()
		{
			return new TransactionManager(this._connectionString);
		}
		
		/// <summary>
		/// Gets a value indicating whether to use stored procedure or not.
		/// </summary>
		/// <value>
		/// 	<c>true</c> if this repository use stored procedures; otherwise, <c>false</c>.
		/// </value>
		public bool UseStoredProcedure
		{
			get {return this._useStoredProcedure;}
			set {this._useStoredProcedure = value;}
		}
		
		 /// <summary>
        /// Gets or sets the connection string.
        /// </summary>
        /// <value>The connection string.</value>
		public string ConnectionString
		{
			get {return this._connectionString;}
			set {this._connectionString = value;}
		}
		
		/// <summary>
	    /// Gets or sets the invariant provider name listed in the DbProviderFactories machine.config section.
	    /// </summary>
	    /// <value>The name of the provider invariant.</value>
	    public string ProviderInvariantName
	    {
	        get { return this._providerInvariantName; }
	        set { this._providerInvariantName = value; }
	    }		
		
		///<summary>
		/// Indicates if the current <see cref="NetTiersProvider"/> implementation supports Transacton.
		///</summary>
		public override bool IsTransactionSupported
		{
			get
			{
				return true;
			}
		}

		
		#region "StockByAditionalImagesLogProvider"
			
		private SqlStockByAditionalImagesLogProvider innerSqlStockByAditionalImagesLogProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="StockByAditionalImagesLog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override StockByAditionalImagesLogProviderBase StockByAditionalImagesLogProvider
		{
			get
			{
				if (innerSqlStockByAditionalImagesLogProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlStockByAditionalImagesLogProvider == null)
						{
							this.innerSqlStockByAditionalImagesLogProvider = new SqlStockByAditionalImagesLogProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlStockByAditionalImagesLogProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlStockByAditionalImagesLogProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlStockByAditionalImagesLogProvider SqlStockByAditionalImagesLogProvider
		{
			get {return StockByAditionalImagesLogProvider as SqlStockByAditionalImagesLogProvider;}
		}
		
		#endregion
		
		
		#region "AdministratorsProvider"
			
		private SqlAdministratorsProvider innerSqlAdministratorsProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Administrators"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override AdministratorsProviderBase AdministratorsProvider
		{
			get
			{
				if (innerSqlAdministratorsProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlAdministratorsProvider == null)
						{
							this.innerSqlAdministratorsProvider = new SqlAdministratorsProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlAdministratorsProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlAdministratorsProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlAdministratorsProvider SqlAdministratorsProvider
		{
			get {return AdministratorsProvider as SqlAdministratorsProvider;}
		}
		
		#endregion
		
		
		#region "StockCategoriesByCompaniesProvider"
			
		private SqlStockCategoriesByCompaniesProvider innerSqlStockCategoriesByCompaniesProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="StockCategoriesByCompanies"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override StockCategoriesByCompaniesProviderBase StockCategoriesByCompaniesProvider
		{
			get
			{
				if (innerSqlStockCategoriesByCompaniesProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlStockCategoriesByCompaniesProvider == null)
						{
							this.innerSqlStockCategoriesByCompaniesProvider = new SqlStockCategoriesByCompaniesProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlStockCategoriesByCompaniesProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlStockCategoriesByCompaniesProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlStockCategoriesByCompaniesProvider SqlStockCategoriesByCompaniesProvider
		{
			get {return StockCategoriesByCompaniesProvider as SqlStockCategoriesByCompaniesProvider;}
		}
		
		#endregion
		
		
		#region "StockCategoriesLogProvider"
			
		private SqlStockCategoriesLogProvider innerSqlStockCategoriesLogProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="StockCategoriesLog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override StockCategoriesLogProviderBase StockCategoriesLogProvider
		{
			get
			{
				if (innerSqlStockCategoriesLogProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlStockCategoriesLogProvider == null)
						{
							this.innerSqlStockCategoriesLogProvider = new SqlStockCategoriesLogProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlStockCategoriesLogProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlStockCategoriesLogProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlStockCategoriesLogProvider SqlStockCategoriesLogProvider
		{
			get {return StockCategoriesLogProvider as SqlStockCategoriesLogProvider;}
		}
		
		#endregion
		
		
		#region "StockCategoriesProvider"
			
		private SqlStockCategoriesProvider innerSqlStockCategoriesProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="StockCategories"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override StockCategoriesProviderBase StockCategoriesProvider
		{
			get
			{
				if (innerSqlStockCategoriesProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlStockCategoriesProvider == null)
						{
							this.innerSqlStockCategoriesProvider = new SqlStockCategoriesProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlStockCategoriesProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlStockCategoriesProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlStockCategoriesProvider SqlStockCategoriesProvider
		{
			get {return StockCategoriesProvider as SqlStockCategoriesProvider;}
		}
		
		#endregion
		
		
		#region "StockByAditionalImagesLogByUuidProvider"
			
		private SqlStockByAditionalImagesLogByUuidProvider innerSqlStockByAditionalImagesLogByUuidProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="StockByAditionalImagesLogByUuid"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override StockByAditionalImagesLogByUuidProviderBase StockByAditionalImagesLogByUuidProvider
		{
			get
			{
				if (innerSqlStockByAditionalImagesLogByUuidProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlStockByAditionalImagesLogByUuidProvider == null)
						{
							this.innerSqlStockByAditionalImagesLogByUuidProvider = new SqlStockByAditionalImagesLogByUuidProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlStockByAditionalImagesLogByUuidProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlStockByAditionalImagesLogByUuidProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlStockByAditionalImagesLogByUuidProvider SqlStockByAditionalImagesLogByUuidProvider
		{
			get {return StockByAditionalImagesLogByUuidProvider as SqlStockByAditionalImagesLogByUuidProvider;}
		}
		
		#endregion
		
		
		#region "StockFilesTypeOfFileProvider"
			
		private SqlStockFilesTypeOfFileProvider innerSqlStockFilesTypeOfFileProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="StockFilesTypeOfFile"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override StockFilesTypeOfFileProviderBase StockFilesTypeOfFileProvider
		{
			get
			{
				if (innerSqlStockFilesTypeOfFileProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlStockFilesTypeOfFileProvider == null)
						{
							this.innerSqlStockFilesTypeOfFileProvider = new SqlStockFilesTypeOfFileProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlStockFilesTypeOfFileProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlStockFilesTypeOfFileProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlStockFilesTypeOfFileProvider SqlStockFilesTypeOfFileProvider
		{
			get {return StockFilesTypeOfFileProvider as SqlStockFilesTypeOfFileProvider;}
		}
		
		#endregion
		
		
		#region "StockCategoriesLogByUuidProvider"
			
		private SqlStockCategoriesLogByUuidProvider innerSqlStockCategoriesLogByUuidProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="StockCategoriesLogByUuid"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override StockCategoriesLogByUuidProviderBase StockCategoriesLogByUuidProvider
		{
			get
			{
				if (innerSqlStockCategoriesLogByUuidProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlStockCategoriesLogByUuidProvider == null)
						{
							this.innerSqlStockCategoriesLogByUuidProvider = new SqlStockCategoriesLogByUuidProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlStockCategoriesLogByUuidProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlStockCategoriesLogByUuidProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlStockCategoriesLogByUuidProvider SqlStockCategoriesLogByUuidProvider
		{
			get {return StockCategoriesLogByUuidProvider as SqlStockCategoriesLogByUuidProvider;}
		}
		
		#endregion
		
		
		#region "StockFilesProvider"
			
		private SqlStockFilesProvider innerSqlStockFilesProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="StockFiles"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override StockFilesProviderBase StockFilesProvider
		{
			get
			{
				if (innerSqlStockFilesProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlStockFilesProvider == null)
						{
							this.innerSqlStockFilesProvider = new SqlStockFilesProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlStockFilesProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlStockFilesProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlStockFilesProvider SqlStockFilesProvider
		{
			get {return StockFilesProvider as SqlStockFilesProvider;}
		}
		
		#endregion
		
		
		#region "StockFilesLogProvider"
			
		private SqlStockFilesLogProvider innerSqlStockFilesLogProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="StockFilesLog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override StockFilesLogProviderBase StockFilesLogProvider
		{
			get
			{
				if (innerSqlStockFilesLogProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlStockFilesLogProvider == null)
						{
							this.innerSqlStockFilesLogProvider = new SqlStockFilesLogProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlStockFilesLogProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlStockFilesLogProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlStockFilesLogProvider SqlStockFilesLogProvider
		{
			get {return StockFilesLogProvider as SqlStockFilesLogProvider;}
		}
		
		#endregion
		
		
		#region "StockFilesByUsernameLogProvider"
			
		private SqlStockFilesByUsernameLogProvider innerSqlStockFilesByUsernameLogProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="StockFilesByUsernameLog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override StockFilesByUsernameLogProviderBase StockFilesByUsernameLogProvider
		{
			get
			{
				if (innerSqlStockFilesByUsernameLogProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlStockFilesByUsernameLogProvider == null)
						{
							this.innerSqlStockFilesByUsernameLogProvider = new SqlStockFilesByUsernameLogProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlStockFilesByUsernameLogProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlStockFilesByUsernameLogProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlStockFilesByUsernameLogProvider SqlStockFilesByUsernameLogProvider
		{
			get {return StockFilesByUsernameLogProvider as SqlStockFilesByUsernameLogProvider;}
		}
		
		#endregion
		
		
		#region "StockFilesLogByUuidProvider"
			
		private SqlStockFilesLogByUuidProvider innerSqlStockFilesLogByUuidProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="StockFilesLogByUuid"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override StockFilesLogByUuidProviderBase StockFilesLogByUuidProvider
		{
			get
			{
				if (innerSqlStockFilesLogByUuidProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlStockFilesLogByUuidProvider == null)
						{
							this.innerSqlStockFilesLogByUuidProvider = new SqlStockFilesLogByUuidProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlStockFilesLogByUuidProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlStockFilesLogByUuidProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlStockFilesLogByUuidProvider SqlStockFilesLogByUuidProvider
		{
			get {return StockFilesLogByUuidProvider as SqlStockFilesLogByUuidProvider;}
		}
		
		#endregion
		
		
		#region "StockFilesByUsernameLogByUuidProvider"
			
		private SqlStockFilesByUsernameLogByUuidProvider innerSqlStockFilesByUsernameLogByUuidProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="StockFilesByUsernameLogByUuid"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override StockFilesByUsernameLogByUuidProviderBase StockFilesByUsernameLogByUuidProvider
		{
			get
			{
				if (innerSqlStockFilesByUsernameLogByUuidProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlStockFilesByUsernameLogByUuidProvider == null)
						{
							this.innerSqlStockFilesByUsernameLogByUuidProvider = new SqlStockFilesByUsernameLogByUuidProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlStockFilesByUsernameLogByUuidProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlStockFilesByUsernameLogByUuidProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlStockFilesByUsernameLogByUuidProvider SqlStockFilesByUsernameLogByUuidProvider
		{
			get {return StockFilesByUsernameLogByUuidProvider as SqlStockFilesByUsernameLogByUuidProvider;}
		}
		
		#endregion
		
		
		#region "StockFilesByUsernameProvider"
			
		private SqlStockFilesByUsernameProvider innerSqlStockFilesByUsernameProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="StockFilesByUsername"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override StockFilesByUsernameProviderBase StockFilesByUsernameProvider
		{
			get
			{
				if (innerSqlStockFilesByUsernameProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlStockFilesByUsernameProvider == null)
						{
							this.innerSqlStockFilesByUsernameProvider = new SqlStockFilesByUsernameProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlStockFilesByUsernameProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlStockFilesByUsernameProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlStockFilesByUsernameProvider SqlStockFilesByUsernameProvider
		{
			get {return StockFilesByUsernameProvider as SqlStockFilesByUsernameProvider;}
		}
		
		#endregion
		
		
		#region "StockProvider"
			
		private SqlStockProvider innerSqlStockProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Stock"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override StockProviderBase StockProvider
		{
			get
			{
				if (innerSqlStockProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlStockProvider == null)
						{
							this.innerSqlStockProvider = new SqlStockProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlStockProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlStockProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlStockProvider SqlStockProvider
		{
			get {return StockProvider as SqlStockProvider;}
		}
		
		#endregion
		
		
		#region "NumCardControlByCompaniesProvider"
			
		private SqlNumCardControlByCompaniesProvider innerSqlNumCardControlByCompaniesProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="NumCardControlByCompanies"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override NumCardControlByCompaniesProviderBase NumCardControlByCompaniesProvider
		{
			get
			{
				if (innerSqlNumCardControlByCompaniesProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlNumCardControlByCompaniesProvider == null)
						{
							this.innerSqlNumCardControlByCompaniesProvider = new SqlNumCardControlByCompaniesProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlNumCardControlByCompaniesProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlNumCardControlByCompaniesProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlNumCardControlByCompaniesProvider SqlNumCardControlByCompaniesProvider
		{
			get {return NumCardControlByCompaniesProvider as SqlNumCardControlByCompaniesProvider;}
		}
		
		#endregion
		
		
		#region "StatusProvider"
			
		private SqlStatusProvider innerSqlStatusProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Status"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override StatusProviderBase StatusProvider
		{
			get
			{
				if (innerSqlStatusProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlStatusProvider == null)
						{
							this.innerSqlStatusProvider = new SqlStatusProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlStatusProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlStatusProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlStatusProvider SqlStatusProvider
		{
			get {return StatusProvider as SqlStatusProvider;}
		}
		
		#endregion
		
		
		#region "OrderProvider"
			
		private SqlOrderProvider innerSqlOrderProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Order"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override OrderProviderBase OrderProvider
		{
			get
			{
				if (innerSqlOrderProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlOrderProvider == null)
						{
							this.innerSqlOrderProvider = new SqlOrderProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlOrderProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlOrderProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlOrderProvider SqlOrderProvider
		{
			get {return OrderProvider as SqlOrderProvider;}
		}
		
		#endregion
		
		
		#region "NotificationTypeProvider"
			
		private SqlNotificationTypeProvider innerSqlNotificationTypeProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="NotificationType"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override NotificationTypeProviderBase NotificationTypeProvider
		{
			get
			{
				if (innerSqlNotificationTypeProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlNotificationTypeProvider == null)
						{
							this.innerSqlNotificationTypeProvider = new SqlNotificationTypeProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlNotificationTypeProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlNotificationTypeProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlNotificationTypeProvider SqlNotificationTypeProvider
		{
			get {return NotificationTypeProvider as SqlNotificationTypeProvider;}
		}
		
		#endregion
		
		
		#region "NotificationsControlDetailsProvider"
			
		private SqlNotificationsControlDetailsProvider innerSqlNotificationsControlDetailsProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="NotificationsControlDetails"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override NotificationsControlDetailsProviderBase NotificationsControlDetailsProvider
		{
			get
			{
				if (innerSqlNotificationsControlDetailsProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlNotificationsControlDetailsProvider == null)
						{
							this.innerSqlNotificationsControlDetailsProvider = new SqlNotificationsControlDetailsProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlNotificationsControlDetailsProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlNotificationsControlDetailsProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlNotificationsControlDetailsProvider SqlNotificationsControlDetailsProvider
		{
			get {return NotificationsControlDetailsProvider as SqlNotificationsControlDetailsProvider;}
		}
		
		#endregion
		
		
		#region "NotificationsTrackDataProvider"
			
		private SqlNotificationsTrackDataProvider innerSqlNotificationsTrackDataProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="NotificationsTrackData"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override NotificationsTrackDataProviderBase NotificationsTrackDataProvider
		{
			get
			{
				if (innerSqlNotificationsTrackDataProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlNotificationsTrackDataProvider == null)
						{
							this.innerSqlNotificationsTrackDataProvider = new SqlNotificationsTrackDataProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlNotificationsTrackDataProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlNotificationsTrackDataProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlNotificationsTrackDataProvider SqlNotificationsTrackDataProvider
		{
			get {return NotificationsTrackDataProvider as SqlNotificationsTrackDataProvider;}
		}
		
		#endregion
		
		
		#region "OrderDetailProvider"
			
		private SqlOrderDetailProvider innerSqlOrderDetailProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="OrderDetail"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override OrderDetailProviderBase OrderDetailProvider
		{
			get
			{
				if (innerSqlOrderDetailProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlOrderDetailProvider == null)
						{
							this.innerSqlOrderDetailProvider = new SqlOrderDetailProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlOrderDetailProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlOrderDetailProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlOrderDetailProvider SqlOrderDetailProvider
		{
			get {return OrderDetailProvider as SqlOrderDetailProvider;}
		}
		
		#endregion
		
		
		#region "NotificationsProvider"
			
		private SqlNotificationsProvider innerSqlNotificationsProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Notifications"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override NotificationsProviderBase NotificationsProvider
		{
			get
			{
				if (innerSqlNotificationsProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlNotificationsProvider == null)
						{
							this.innerSqlNotificationsProvider = new SqlNotificationsProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlNotificationsProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlNotificationsProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlNotificationsProvider SqlNotificationsProvider
		{
			get {return NotificationsProvider as SqlNotificationsProvider;}
		}
		
		#endregion
		
		
		#region "SettingProvider"
			
		private SqlSettingProvider innerSqlSettingProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Setting"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override SettingProviderBase SettingProvider
		{
			get
			{
				if (innerSqlSettingProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlSettingProvider == null)
						{
							this.innerSqlSettingProvider = new SqlSettingProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlSettingProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlSettingProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlSettingProvider SqlSettingProvider
		{
			get {return SettingProvider as SqlSettingProvider;}
		}
		
		#endregion
		
		
		#region "RoutesProvider"
			
		private SqlRoutesProvider innerSqlRoutesProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Routes"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override RoutesProviderBase RoutesProvider
		{
			get
			{
				if (innerSqlRoutesProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlRoutesProvider == null)
						{
							this.innerSqlRoutesProvider = new SqlRoutesProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlRoutesProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlRoutesProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlRoutesProvider SqlRoutesProvider
		{
			get {return RoutesProvider as SqlRoutesProvider;}
		}
		
		#endregion
		
		
		#region "SequenceByCompaniesProvider"
			
		private SqlSequenceByCompaniesProvider innerSqlSequenceByCompaniesProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="SequenceByCompanies"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override SequenceByCompaniesProviderBase SequenceByCompaniesProvider
		{
			get
			{
				if (innerSqlSequenceByCompaniesProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlSequenceByCompaniesProvider == null)
						{
							this.innerSqlSequenceByCompaniesProvider = new SqlSequenceByCompaniesProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlSequenceByCompaniesProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlSequenceByCompaniesProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlSequenceByCompaniesProvider SqlSequenceByCompaniesProvider
		{
			get {return SequenceByCompaniesProvider as SqlSequenceByCompaniesProvider;}
		}
		
		#endregion
		
		
		#region "StockByAditionalImagesProvider"
			
		private SqlStockByAditionalImagesProvider innerSqlStockByAditionalImagesProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="StockByAditionalImages"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override StockByAditionalImagesProviderBase StockByAditionalImagesProvider
		{
			get
			{
				if (innerSqlStockByAditionalImagesProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlStockByAditionalImagesProvider == null)
						{
							this.innerSqlStockByAditionalImagesProvider = new SqlStockByAditionalImagesProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlStockByAditionalImagesProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlStockByAditionalImagesProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlStockByAditionalImagesProvider SqlStockByAditionalImagesProvider
		{
			get {return StockByAditionalImagesProvider as SqlStockByAditionalImagesProvider;}
		}
		
		#endregion
		
		
		#region "ScheduleWorkProvider"
			
		private SqlScheduleWorkProvider innerSqlScheduleWorkProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ScheduleWork"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ScheduleWorkProviderBase ScheduleWorkProvider
		{
			get
			{
				if (innerSqlScheduleWorkProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlScheduleWorkProvider == null)
						{
							this.innerSqlScheduleWorkProvider = new SqlScheduleWorkProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlScheduleWorkProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlScheduleWorkProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlScheduleWorkProvider SqlScheduleWorkProvider
		{
			get {return ScheduleWorkProvider as SqlScheduleWorkProvider;}
		}
		
		#endregion
		
		
		#region "SequenceProvider"
			
		private SqlSequenceProvider innerSqlSequenceProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Sequence"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override SequenceProviderBase SequenceProvider
		{
			get
			{
				if (innerSqlSequenceProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlSequenceProvider == null)
						{
							this.innerSqlSequenceProvider = new SqlSequenceProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlSequenceProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlSequenceProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlSequenceProvider SqlSequenceProvider
		{
			get {return SequenceProvider as SqlSequenceProvider;}
		}
		
		#endregion
		
		
		#region "StockFilesTypeOfFileLogProvider"
			
		private SqlStockFilesTypeOfFileLogProvider innerSqlStockFilesTypeOfFileLogProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="StockFilesTypeOfFileLog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override StockFilesTypeOfFileLogProviderBase StockFilesTypeOfFileLogProvider
		{
			get
			{
				if (innerSqlStockFilesTypeOfFileLogProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlStockFilesTypeOfFileLogProvider == null)
						{
							this.innerSqlStockFilesTypeOfFileLogProvider = new SqlStockFilesTypeOfFileLogProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlStockFilesTypeOfFileLogProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlStockFilesTypeOfFileLogProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlStockFilesTypeOfFileLogProvider SqlStockFilesTypeOfFileLogProvider
		{
			get {return StockFilesTypeOfFileLogProvider as SqlStockFilesTypeOfFileLogProvider;}
		}
		
		#endregion
		
		
		#region "ScheduleWorkByCompaniesProvider"
			
		private SqlScheduleWorkByCompaniesProvider innerSqlScheduleWorkByCompaniesProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ScheduleWorkByCompanies"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ScheduleWorkByCompaniesProviderBase ScheduleWorkByCompaniesProvider
		{
			get
			{
				if (innerSqlScheduleWorkByCompaniesProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlScheduleWorkByCompaniesProvider == null)
						{
							this.innerSqlScheduleWorkByCompaniesProvider = new SqlScheduleWorkByCompaniesProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlScheduleWorkByCompaniesProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlScheduleWorkByCompaniesProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlScheduleWorkByCompaniesProvider SqlScheduleWorkByCompaniesProvider
		{
			get {return ScheduleWorkByCompaniesProvider as SqlScheduleWorkByCompaniesProvider;}
		}
		
		#endregion
		
		
		#region "UsersLogProvider"
			
		private SqlUsersLogProvider innerSqlUsersLogProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="UsersLog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override UsersLogProviderBase UsersLogProvider
		{
			get
			{
				if (innerSqlUsersLogProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlUsersLogProvider == null)
						{
							this.innerSqlUsersLogProvider = new SqlUsersLogProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlUsersLogProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlUsersLogProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlUsersLogProvider SqlUsersLogProvider
		{
			get {return UsersLogProvider as SqlUsersLogProvider;}
		}
		
		#endregion
		
		
		#region "UsersGroupsProvider"
			
		private SqlUsersGroupsProvider innerSqlUsersGroupsProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="UsersGroups"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override UsersGroupsProviderBase UsersGroupsProvider
		{
			get
			{
				if (innerSqlUsersGroupsProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlUsersGroupsProvider == null)
						{
							this.innerSqlUsersGroupsProvider = new SqlUsersGroupsProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlUsersGroupsProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlUsersGroupsProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlUsersGroupsProvider SqlUsersGroupsProvider
		{
			get {return UsersGroupsProvider as SqlUsersGroupsProvider;}
		}
		
		#endregion
		
		
		#region "UsersGroupsByDepartmentsProvider"
			
		private SqlUsersGroupsByDepartmentsProvider innerSqlUsersGroupsByDepartmentsProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="UsersGroupsByDepartments"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override UsersGroupsByDepartmentsProviderBase UsersGroupsByDepartmentsProvider
		{
			get
			{
				if (innerSqlUsersGroupsByDepartmentsProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlUsersGroupsByDepartmentsProvider == null)
						{
							this.innerSqlUsersGroupsByDepartmentsProvider = new SqlUsersGroupsByDepartmentsProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlUsersGroupsByDepartmentsProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlUsersGroupsByDepartmentsProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlUsersGroupsByDepartmentsProvider SqlUsersGroupsByDepartmentsProvider
		{
			get {return UsersGroupsByDepartmentsProvider as SqlUsersGroupsByDepartmentsProvider;}
		}
		
		#endregion
		
		
		#region "CompaniesProvider"
			
		private SqlCompaniesProvider innerSqlCompaniesProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Companies"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override CompaniesProviderBase CompaniesProvider
		{
			get
			{
				if (innerSqlCompaniesProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlCompaniesProvider == null)
						{
							this.innerSqlCompaniesProvider = new SqlCompaniesProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlCompaniesProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlCompaniesProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlCompaniesProvider SqlCompaniesProvider
		{
			get {return CompaniesProvider as SqlCompaniesProvider;}
		}
		
		#endregion
		
		
		#region "UsersLogByUuidProvider"
			
		private SqlUsersLogByUuidProvider innerSqlUsersLogByUuidProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="UsersLogByUuid"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override UsersLogByUuidProviderBase UsersLogByUuidProvider
		{
			get
			{
				if (innerSqlUsersLogByUuidProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlUsersLogByUuidProvider == null)
						{
							this.innerSqlUsersLogByUuidProvider = new SqlUsersLogByUuidProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlUsersLogByUuidProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlUsersLogByUuidProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlUsersLogByUuidProvider SqlUsersLogByUuidProvider
		{
			get {return UsersLogByUuidProvider as SqlUsersLogByUuidProvider;}
		}
		
		#endregion
		
		
		#region "UsersProvider"
			
		private SqlUsersProvider innerSqlUsersProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Users"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override UsersProviderBase UsersProvider
		{
			get
			{
				if (innerSqlUsersProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlUsersProvider == null)
						{
							this.innerSqlUsersProvider = new SqlUsersProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlUsersProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlUsersProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlUsersProvider SqlUsersProvider
		{
			get {return UsersProvider as SqlUsersProvider;}
		}
		
		#endregion
		
		
		#region "UsersByUsersGroupsProvider"
			
		private SqlUsersByUsersGroupsProvider innerSqlUsersByUsersGroupsProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="UsersByUsersGroups"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override UsersByUsersGroupsProviderBase UsersByUsersGroupsProvider
		{
			get
			{
				if (innerSqlUsersByUsersGroupsProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlUsersByUsersGroupsProvider == null)
						{
							this.innerSqlUsersByUsersGroupsProvider = new SqlUsersByUsersGroupsProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlUsersByUsersGroupsProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlUsersByUsersGroupsProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlUsersByUsersGroupsProvider SqlUsersByUsersGroupsProvider
		{
			get {return UsersByUsersGroupsProvider as SqlUsersByUsersGroupsProvider;}
		}
		
		#endregion
		
		
		#region "StockFilesTypeOfFileLogByUuidProvider"
			
		private SqlStockFilesTypeOfFileLogByUuidProvider innerSqlStockFilesTypeOfFileLogByUuidProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="StockFilesTypeOfFileLogByUuid"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override StockFilesTypeOfFileLogByUuidProviderBase StockFilesTypeOfFileLogByUuidProvider
		{
			get
			{
				if (innerSqlStockFilesTypeOfFileLogByUuidProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlStockFilesTypeOfFileLogByUuidProvider == null)
						{
							this.innerSqlStockFilesTypeOfFileLogByUuidProvider = new SqlStockFilesTypeOfFileLogByUuidProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlStockFilesTypeOfFileLogByUuidProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlStockFilesTypeOfFileLogByUuidProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlStockFilesTypeOfFileLogByUuidProvider SqlStockFilesTypeOfFileLogByUuidProvider
		{
			get {return StockFilesTypeOfFileLogByUuidProvider as SqlStockFilesTypeOfFileLogByUuidProvider;}
		}
		
		#endregion
		
		
		#region "VpcControlProvider"
			
		private SqlVpcControlProvider innerSqlVpcControlProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VpcControl"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VpcControlProviderBase VpcControlProvider
		{
			get
			{
				if (innerSqlVpcControlProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVpcControlProvider == null)
						{
							this.innerSqlVpcControlProvider = new SqlVpcControlProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVpcControlProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlVpcControlProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVpcControlProvider SqlVpcControlProvider
		{
			get {return VpcControlProvider as SqlVpcControlProvider;}
		}
		
		#endregion
		
		
		#region "UsersByGpsStocksProvider"
			
		private SqlUsersByGpsStocksProvider innerSqlUsersByGpsStocksProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="UsersByGpsStocks"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override UsersByGpsStocksProviderBase UsersByGpsStocksProvider
		{
			get
			{
				if (innerSqlUsersByGpsStocksProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlUsersByGpsStocksProvider == null)
						{
							this.innerSqlUsersByGpsStocksProvider = new SqlUsersByGpsStocksProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlUsersByGpsStocksProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlUsersByGpsStocksProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlUsersByGpsStocksProvider SqlUsersByGpsStocksProvider
		{
			get {return UsersByGpsStocksProvider as SqlUsersByGpsStocksProvider;}
		}
		
		#endregion
		
		
		#region "VpcTrackDataProvider"
			
		private SqlVpcTrackDataProvider innerSqlVpcTrackDataProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VpcTrackData"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VpcTrackDataProviderBase VpcTrackDataProvider
		{
			get
			{
				if (innerSqlVpcTrackDataProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVpcTrackDataProvider == null)
						{
							this.innerSqlVpcTrackDataProvider = new SqlVpcTrackDataProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVpcTrackDataProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlVpcTrackDataProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVpcTrackDataProvider SqlVpcTrackDataProvider
		{
			get {return VpcTrackDataProvider as SqlVpcTrackDataProvider;}
		}
		
		#endregion
		
		
		#region "VpcRecordTypeProvider"
			
		private SqlVpcRecordTypeProvider innerSqlVpcRecordTypeProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VpcRecordType"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VpcRecordTypeProviderBase VpcRecordTypeProvider
		{
			get
			{
				if (innerSqlVpcRecordTypeProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVpcRecordTypeProvider == null)
						{
							this.innerSqlVpcRecordTypeProvider = new SqlVpcRecordTypeProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVpcRecordTypeProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlVpcRecordTypeProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVpcRecordTypeProvider SqlVpcRecordTypeProvider
		{
			get {return VpcRecordTypeProvider as SqlVpcRecordTypeProvider;}
		}
		
		#endregion
		
		
		#region "VpcRecordLsProvider"
			
		private SqlVpcRecordLsProvider innerSqlVpcRecordLsProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VpcRecordLs"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VpcRecordLsProviderBase VpcRecordLsProvider
		{
			get
			{
				if (innerSqlVpcRecordLsProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVpcRecordLsProvider == null)
						{
							this.innerSqlVpcRecordLsProvider = new SqlVpcRecordLsProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVpcRecordLsProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlVpcRecordLsProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVpcRecordLsProvider SqlVpcRecordLsProvider
		{
			get {return VpcRecordLsProvider as SqlVpcRecordLsProvider;}
		}
		
		#endregion
		
		
		#region "VpcProcessProvider"
			
		private SqlVpcProcessProvider innerSqlVpcProcessProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VpcProcess"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VpcProcessProviderBase VpcProcessProvider
		{
			get
			{
				if (innerSqlVpcProcessProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVpcProcessProvider == null)
						{
							this.innerSqlVpcProcessProvider = new SqlVpcProcessProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVpcProcessProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlVpcProcessProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVpcProcessProvider SqlVpcProcessProvider
		{
			get {return VpcProcessProvider as SqlVpcProcessProvider;}
		}
		
		#endregion
		
		
		#region "VpcProcessDetailsProvider"
			
		private SqlVpcProcessDetailsProvider innerSqlVpcProcessDetailsProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VpcProcessDetails"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VpcProcessDetailsProviderBase VpcProcessDetailsProvider
		{
			get
			{
				if (innerSqlVpcProcessDetailsProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVpcProcessDetailsProvider == null)
						{
							this.innerSqlVpcProcessDetailsProvider = new SqlVpcProcessDetailsProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVpcProcessDetailsProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlVpcProcessDetailsProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVpcProcessDetailsProvider SqlVpcProcessDetailsProvider
		{
			get {return VpcProcessDetailsProvider as SqlVpcProcessDetailsProvider;}
		}
		
		#endregion
		
		
		#region "WindowsServicesLogProvider"
			
		private SqlWindowsServicesLogProvider innerSqlWindowsServicesLogProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="WindowsServicesLog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override WindowsServicesLogProviderBase WindowsServicesLogProvider
		{
			get
			{
				if (innerSqlWindowsServicesLogProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlWindowsServicesLogProvider == null)
						{
							this.innerSqlWindowsServicesLogProvider = new SqlWindowsServicesLogProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlWindowsServicesLogProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlWindowsServicesLogProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlWindowsServicesLogProvider SqlWindowsServicesLogProvider
		{
			get {return WindowsServicesLogProvider as SqlWindowsServicesLogProvider;}
		}
		
		#endregion
		
		
		#region "UsersByGpsGroupsProvider"
			
		private SqlUsersByGpsGroupsProvider innerSqlUsersByGpsGroupsProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="UsersByGpsGroups"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override UsersByGpsGroupsProviderBase UsersByGpsGroupsProvider
		{
			get
			{
				if (innerSqlUsersByGpsGroupsProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlUsersByGpsGroupsProvider == null)
						{
							this.innerSqlUsersByGpsGroupsProvider = new SqlUsersByGpsGroupsProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlUsersByGpsGroupsProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlUsersByGpsGroupsProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlUsersByGpsGroupsProvider SqlUsersByGpsGroupsProvider
		{
			get {return UsersByGpsGroupsProvider as SqlUsersByGpsGroupsProvider;}
		}
		
		#endregion
		
		
		#region "UsersByEmailProvider"
			
		private SqlUsersByEmailProvider innerSqlUsersByEmailProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="UsersByEmail"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override UsersByEmailProviderBase UsersByEmailProvider
		{
			get
			{
				if (innerSqlUsersByEmailProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlUsersByEmailProvider == null)
						{
							this.innerSqlUsersByEmailProvider = new SqlUsersByEmailProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlUsersByEmailProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlUsersByEmailProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlUsersByEmailProvider SqlUsersByEmailProvider
		{
			get {return UsersByEmailProvider as SqlUsersByEmailProvider;}
		}
		
		#endregion
		
		
		#region "TrackDataProvider"
			
		private SqlTrackDataProvider innerSqlTrackDataProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="TrackData"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override TrackDataProviderBase TrackDataProvider
		{
			get
			{
				if (innerSqlTrackDataProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlTrackDataProvider == null)
						{
							this.innerSqlTrackDataProvider = new SqlTrackDataProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlTrackDataProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlTrackDataProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlTrackDataProvider SqlTrackDataProvider
		{
			get {return TrackDataProvider as SqlTrackDataProvider;}
		}
		
		#endregion
		
		
		#region "StockSettingProvider"
			
		private SqlStockSettingProvider innerSqlStockSettingProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="StockSetting"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override StockSettingProviderBase StockSettingProvider
		{
			get
			{
				if (innerSqlStockSettingProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlStockSettingProvider == null)
						{
							this.innerSqlStockSettingProvider = new SqlStockSettingProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlStockSettingProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlStockSettingProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlStockSettingProvider SqlStockSettingProvider
		{
			get {return StockSettingProvider as SqlStockSettingProvider;}
		}
		
		#endregion
		
		
		#region "StockLogProvider"
			
		private SqlStockLogProvider innerSqlStockLogProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="StockLog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override StockLogProviderBase StockLogProvider
		{
			get
			{
				if (innerSqlStockLogProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlStockLogProvider == null)
						{
							this.innerSqlStockLogProvider = new SqlStockLogProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlStockLogProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlStockLogProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlStockLogProvider SqlStockLogProvider
		{
			get {return StockLogProvider as SqlStockLogProvider;}
		}
		
		#endregion
		
		
		#region "StockLogByUuidProvider"
			
		private SqlStockLogByUuidProvider innerSqlStockLogByUuidProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="StockLogByUuid"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override StockLogByUuidProviderBase StockLogByUuidProvider
		{
			get
			{
				if (innerSqlStockLogByUuidProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlStockLogByUuidProvider == null)
						{
							this.innerSqlStockLogByUuidProvider = new SqlStockLogByUuidProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlStockLogByUuidProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlStockLogByUuidProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlStockLogByUuidProvider SqlStockLogByUuidProvider
		{
			get {return StockLogByUuidProvider as SqlStockLogByUuidProvider;}
		}
		
		#endregion
		
		
		#region "TrackDataByClientsProvider"
			
		private SqlTrackDataByClientsProvider innerSqlTrackDataByClientsProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="TrackDataByClients"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override TrackDataByClientsProviderBase TrackDataByClientsProvider
		{
			get
			{
				if (innerSqlTrackDataByClientsProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlTrackDataByClientsProvider == null)
						{
							this.innerSqlTrackDataByClientsProvider = new SqlTrackDataByClientsProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlTrackDataByClientsProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlTrackDataByClientsProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlTrackDataByClientsProvider SqlTrackDataByClientsProvider
		{
			get {return TrackDataByClientsProvider as SqlTrackDataByClientsProvider;}
		}
		
		#endregion
		
		
		#region "StockSettingValuesProvider"
			
		private SqlStockSettingValuesProvider innerSqlStockSettingValuesProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="StockSettingValues"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override StockSettingValuesProviderBase StockSettingValuesProvider
		{
			get
			{
				if (innerSqlStockSettingValuesProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlStockSettingValuesProvider == null)
						{
							this.innerSqlStockSettingValuesProvider = new SqlStockSettingValuesProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlStockSettingValuesProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlStockSettingValuesProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlStockSettingValuesProvider SqlStockSettingValuesProvider
		{
			get {return StockSettingValuesProvider as SqlStockSettingValuesProvider;}
		}
		
		#endregion
		
		
		#region "TrackDataLastLocationProvider"
			
		private SqlTrackDataLastLocationProvider innerSqlTrackDataLastLocationProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="TrackDataLastLocation"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override TrackDataLastLocationProviderBase TrackDataLastLocationProvider
		{
			get
			{
				if (innerSqlTrackDataLastLocationProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlTrackDataLastLocationProvider == null)
						{
							this.innerSqlTrackDataLastLocationProvider = new SqlTrackDataLastLocationProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlTrackDataLastLocationProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlTrackDataLastLocationProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlTrackDataLastLocationProvider SqlTrackDataLastLocationProvider
		{
			get {return TrackDataLastLocationProvider as SqlTrackDataLastLocationProvider;}
		}
		
		#endregion
		
		
		#region "UserRolesProvider"
			
		private SqlUserRolesProvider innerSqlUserRolesProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="UserRoles"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override UserRolesProviderBase UserRolesProvider
		{
			get
			{
				if (innerSqlUserRolesProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlUserRolesProvider == null)
						{
							this.innerSqlUserRolesProvider = new SqlUserRolesProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlUserRolesProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlUserRolesProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlUserRolesProvider SqlUserRolesProvider
		{
			get {return UserRolesProvider as SqlUserRolesProvider;}
		}
		
		#endregion
		
		
		#region "UserRolesByUsersProvider"
			
		private SqlUserRolesByUsersProvider innerSqlUserRolesByUsersProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="UserRolesByUsers"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override UserRolesByUsersProviderBase UserRolesByUsersProvider
		{
			get
			{
				if (innerSqlUserRolesByUsersProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlUserRolesByUsersProvider == null)
						{
							this.innerSqlUserRolesByUsersProvider = new SqlUserRolesByUsersProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlUserRolesByUsersProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlUserRolesByUsersProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlUserRolesByUsersProvider SqlUserRolesByUsersProvider
		{
			get {return UserRolesByUsersProvider as SqlUserRolesByUsersProvider;}
		}
		
		#endregion
		
		
		#region "TypeModulesProvider"
			
		private SqlTypeModulesProvider innerSqlTypeModulesProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="TypeModules"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override TypeModulesProviderBase TypeModulesProvider
		{
			get
			{
				if (innerSqlTypeModulesProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlTypeModulesProvider == null)
						{
							this.innerSqlTypeModulesProvider = new SqlTypeModulesProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlTypeModulesProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlTypeModulesProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlTypeModulesProvider SqlTypeModulesProvider
		{
			get {return TypeModulesProvider as SqlTypeModulesProvider;}
		}
		
		#endregion
		
		
		#region "TrackDataLastVpcProvider"
			
		private SqlTrackDataLastVpcProvider innerSqlTrackDataLastVpcProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="TrackDataLastVpc"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override TrackDataLastVpcProviderBase TrackDataLastVpcProvider
		{
			get
			{
				if (innerSqlTrackDataLastVpcProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlTrackDataLastVpcProvider == null)
						{
							this.innerSqlTrackDataLastVpcProvider = new SqlTrackDataLastVpcProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlTrackDataLastVpcProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlTrackDataLastVpcProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlTrackDataLastVpcProvider SqlTrackDataLastVpcProvider
		{
			get {return TrackDataLastVpcProvider as SqlTrackDataLastVpcProvider;}
		}
		
		#endregion
		
		
		#region "TrackDataLastLocationNotificationsProvider"
			
		private SqlTrackDataLastLocationNotificationsProvider innerSqlTrackDataLastLocationNotificationsProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="TrackDataLastLocationNotifications"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override TrackDataLastLocationNotificationsProviderBase TrackDataLastLocationNotificationsProvider
		{
			get
			{
				if (innerSqlTrackDataLastLocationNotificationsProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlTrackDataLastLocationNotificationsProvider == null)
						{
							this.innerSqlTrackDataLastLocationNotificationsProvider = new SqlTrackDataLastLocationNotificationsProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlTrackDataLastLocationNotificationsProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlTrackDataLastLocationNotificationsProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlTrackDataLastLocationNotificationsProvider SqlTrackDataLastLocationNotificationsProvider
		{
			get {return TrackDataLastLocationNotificationsProvider as SqlTrackDataLastLocationNotificationsProvider;}
		}
		
		#endregion
		
		
		#region "NotificationsControlProvider"
			
		private SqlNotificationsControlProvider innerSqlNotificationsControlProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="NotificationsControl"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override NotificationsControlProviderBase NotificationsControlProvider
		{
			get
			{
				if (innerSqlNotificationsControlProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlNotificationsControlProvider == null)
						{
							this.innerSqlNotificationsControlProvider = new SqlNotificationsControlProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlNotificationsControlProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlNotificationsControlProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlNotificationsControlProvider SqlNotificationsControlProvider
		{
			get {return NotificationsControlProvider as SqlNotificationsControlProvider;}
		}
		
		#endregion
		
		
		#region "NotificationsByGpsProvider"
			
		private SqlNotificationsByGpsProvider innerSqlNotificationsByGpsProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="NotificationsByGps"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override NotificationsByGpsProviderBase NotificationsByGpsProvider
		{
			get
			{
				if (innerSqlNotificationsByGpsProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlNotificationsByGpsProvider == null)
						{
							this.innerSqlNotificationsByGpsProvider = new SqlNotificationsByGpsProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlNotificationsByGpsProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlNotificationsByGpsProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlNotificationsByGpsProvider SqlNotificationsByGpsProvider
		{
			get {return NotificationsByGpsProvider as SqlNotificationsByGpsProvider;}
		}
		
		#endregion
		
		
		#region "ClientsLogProvider"
			
		private SqlClientsLogProvider innerSqlClientsLogProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ClientsLog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ClientsLogProviderBase ClientsLogProvider
		{
			get
			{
				if (innerSqlClientsLogProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlClientsLogProvider == null)
						{
							this.innerSqlClientsLogProvider = new SqlClientsLogProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlClientsLogProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlClientsLogProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlClientsLogProvider SqlClientsLogProvider
		{
			get {return ClientsLogProvider as SqlClientsLogProvider;}
		}
		
		#endregion
		
		
		#region "ClientsGroupsProvider"
			
		private SqlClientsGroupsProvider innerSqlClientsGroupsProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ClientsGroups"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ClientsGroupsProviderBase ClientsGroupsProvider
		{
			get
			{
				if (innerSqlClientsGroupsProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlClientsGroupsProvider == null)
						{
							this.innerSqlClientsGroupsProvider = new SqlClientsGroupsProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlClientsGroupsProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlClientsGroupsProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlClientsGroupsProvider SqlClientsGroupsProvider
		{
			get {return ClientsGroupsProvider as SqlClientsGroupsProvider;}
		}
		
		#endregion
		
		
		#region "ClientsControlProvider"
			
		private SqlClientsControlProvider innerSqlClientsControlProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ClientsControl"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ClientsControlProviderBase ClientsControlProvider
		{
			get
			{
				if (innerSqlClientsControlProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlClientsControlProvider == null)
						{
							this.innerSqlClientsControlProvider = new SqlClientsControlProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlClientsControlProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlClientsControlProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlClientsControlProvider SqlClientsControlProvider
		{
			get {return ClientsControlProvider as SqlClientsControlProvider;}
		}
		
		#endregion
		
		
		#region "ClientsProvider"
			
		private SqlClientsProvider innerSqlClientsProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Clients"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ClientsProviderBase ClientsProvider
		{
			get
			{
				if (innerSqlClientsProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlClientsProvider == null)
						{
							this.innerSqlClientsProvider = new SqlClientsProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlClientsProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlClientsProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlClientsProvider SqlClientsProvider
		{
			get {return ClientsProvider as SqlClientsProvider;}
		}
		
		#endregion
		
		
		#region "ClientsLogByUuidProvider"
			
		private SqlClientsLogByUuidProvider innerSqlClientsLogByUuidProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ClientsLogByUuid"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ClientsLogByUuidProviderBase ClientsLogByUuidProvider
		{
			get
			{
				if (innerSqlClientsLogByUuidProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlClientsLogByUuidProvider == null)
						{
							this.innerSqlClientsLogByUuidProvider = new SqlClientsLogByUuidProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlClientsLogByUuidProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlClientsLogByUuidProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlClientsLogByUuidProvider SqlClientsLogByUuidProvider
		{
			get {return ClientsLogByUuidProvider as SqlClientsLogByUuidProvider;}
		}
		
		#endregion
		
		
		#region "ClientsGroupsByCompaniesProvider"
			
		private SqlClientsGroupsByCompaniesProvider innerSqlClientsGroupsByCompaniesProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ClientsGroupsByCompanies"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ClientsGroupsByCompaniesProviderBase ClientsGroupsByCompaniesProvider
		{
			get
			{
				if (innerSqlClientsGroupsByCompaniesProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlClientsGroupsByCompaniesProvider == null)
						{
							this.innerSqlClientsGroupsByCompaniesProvider = new SqlClientsGroupsByCompaniesProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlClientsGroupsByCompaniesProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlClientsGroupsByCompaniesProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlClientsGroupsByCompaniesProvider SqlClientsGroupsByCompaniesProvider
		{
			get {return ClientsGroupsByCompaniesProvider as SqlClientsGroupsByCompaniesProvider;}
		}
		
		#endregion
		
		
		#region "ClientsToVisitProvider"
			
		private SqlClientsToVisitProvider innerSqlClientsToVisitProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ClientsToVisit"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ClientsToVisitProviderBase ClientsToVisitProvider
		{
			get
			{
				if (innerSqlClientsToVisitProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlClientsToVisitProvider == null)
						{
							this.innerSqlClientsToVisitProvider = new SqlClientsToVisitProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlClientsToVisitProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlClientsToVisitProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlClientsToVisitProvider SqlClientsToVisitProvider
		{
			get {return ClientsToVisitProvider as SqlClientsToVisitProvider;}
		}
		
		#endregion
		
		
		#region "CompaniesByAdministratorsRolesProvider"
			
		private SqlCompaniesByAdministratorsRolesProvider innerSqlCompaniesByAdministratorsRolesProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="CompaniesByAdministratorsRoles"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override CompaniesByAdministratorsRolesProviderBase CompaniesByAdministratorsRolesProvider
		{
			get
			{
				if (innerSqlCompaniesByAdministratorsRolesProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlCompaniesByAdministratorsRolesProvider == null)
						{
							this.innerSqlCompaniesByAdministratorsRolesProvider = new SqlCompaniesByAdministratorsRolesProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlCompaniesByAdministratorsRolesProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlCompaniesByAdministratorsRolesProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlCompaniesByAdministratorsRolesProvider SqlCompaniesByAdministratorsRolesProvider
		{
			get {return CompaniesByAdministratorsRolesProvider as SqlCompaniesByAdministratorsRolesProvider;}
		}
		
		#endregion
		
		
		#region "CompaniesByMenuProvider"
			
		private SqlCompaniesByMenuProvider innerSqlCompaniesByMenuProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="CompaniesByMenu"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override CompaniesByMenuProviderBase CompaniesByMenuProvider
		{
			get
			{
				if (innerSqlCompaniesByMenuProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlCompaniesByMenuProvider == null)
						{
							this.innerSqlCompaniesByMenuProvider = new SqlCompaniesByMenuProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlCompaniesByMenuProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlCompaniesByMenuProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlCompaniesByMenuProvider SqlCompaniesByMenuProvider
		{
			get {return CompaniesByMenuProvider as SqlCompaniesByMenuProvider;}
		}
		
		#endregion
		
		
		#region "CompaniesByMastersProvider"
			
		private SqlCompaniesByMastersProvider innerSqlCompaniesByMastersProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="CompaniesByMasters"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override CompaniesByMastersProviderBase CompaniesByMastersProvider
		{
			get
			{
				if (innerSqlCompaniesByMastersProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlCompaniesByMastersProvider == null)
						{
							this.innerSqlCompaniesByMastersProvider = new SqlCompaniesByMastersProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlCompaniesByMastersProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlCompaniesByMastersProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlCompaniesByMastersProvider SqlCompaniesByMastersProvider
		{
			get {return CompaniesByMastersProvider as SqlCompaniesByMastersProvider;}
		}
		
		#endregion
		
		
		#region "CompaniesByGpsGroupsProvider"
			
		private SqlCompaniesByGpsGroupsProvider innerSqlCompaniesByGpsGroupsProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="CompaniesByGpsGroups"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override CompaniesByGpsGroupsProviderBase CompaniesByGpsGroupsProvider
		{
			get
			{
				if (innerSqlCompaniesByGpsGroupsProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlCompaniesByGpsGroupsProvider == null)
						{
							this.innerSqlCompaniesByGpsGroupsProvider = new SqlCompaniesByGpsGroupsProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlCompaniesByGpsGroupsProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlCompaniesByGpsGroupsProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlCompaniesByGpsGroupsProvider SqlCompaniesByGpsGroupsProvider
		{
			get {return CompaniesByGpsGroupsProvider as SqlCompaniesByGpsGroupsProvider;}
		}
		
		#endregion
		
		
		#region "CompaniesByGeoFencesProvider"
			
		private SqlCompaniesByGeoFencesProvider innerSqlCompaniesByGeoFencesProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="CompaniesByGeoFences"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override CompaniesByGeoFencesProviderBase CompaniesByGeoFencesProvider
		{
			get
			{
				if (innerSqlCompaniesByGeoFencesProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlCompaniesByGeoFencesProvider == null)
						{
							this.innerSqlCompaniesByGeoFencesProvider = new SqlCompaniesByGeoFencesProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlCompaniesByGeoFencesProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlCompaniesByGeoFencesProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlCompaniesByGeoFencesProvider SqlCompaniesByGeoFencesProvider
		{
			get {return CompaniesByGeoFencesProvider as SqlCompaniesByGeoFencesProvider;}
		}
		
		#endregion
		
		
		#region "CompaniesByDepartmentsProvider"
			
		private SqlCompaniesByDepartmentsProvider innerSqlCompaniesByDepartmentsProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="CompaniesByDepartments"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override CompaniesByDepartmentsProviderBase CompaniesByDepartmentsProvider
		{
			get
			{
				if (innerSqlCompaniesByDepartmentsProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlCompaniesByDepartmentsProvider == null)
						{
							this.innerSqlCompaniesByDepartmentsProvider = new SqlCompaniesByDepartmentsProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlCompaniesByDepartmentsProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlCompaniesByDepartmentsProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlCompaniesByDepartmentsProvider SqlCompaniesByDepartmentsProvider
		{
			get {return CompaniesByDepartmentsProvider as SqlCompaniesByDepartmentsProvider;}
		}
		
		#endregion
		
		
		#region "ClientsByEmailLogByUuidProvider"
			
		private SqlClientsByEmailLogByUuidProvider innerSqlClientsByEmailLogByUuidProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ClientsByEmailLogByUuid"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ClientsByEmailLogByUuidProviderBase ClientsByEmailLogByUuidProvider
		{
			get
			{
				if (innerSqlClientsByEmailLogByUuidProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlClientsByEmailLogByUuidProvider == null)
						{
							this.innerSqlClientsByEmailLogByUuidProvider = new SqlClientsByEmailLogByUuidProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlClientsByEmailLogByUuidProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlClientsByEmailLogByUuidProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlClientsByEmailLogByUuidProvider SqlClientsByEmailLogByUuidProvider
		{
			get {return ClientsByEmailLogByUuidProvider as SqlClientsByEmailLogByUuidProvider;}
		}
		
		#endregion
		
		
		#region "ClientsByEmailLogProvider"
			
		private SqlClientsByEmailLogProvider innerSqlClientsByEmailLogProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ClientsByEmailLog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ClientsByEmailLogProviderBase ClientsByEmailLogProvider
		{
			get
			{
				if (innerSqlClientsByEmailLogProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlClientsByEmailLogProvider == null)
						{
							this.innerSqlClientsByEmailLogProvider = new SqlClientsByEmailLogProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlClientsByEmailLogProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlClientsByEmailLogProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlClientsByEmailLogProvider SqlClientsByEmailLogProvider
		{
			get {return ClientsByEmailLogProvider as SqlClientsByEmailLogProvider;}
		}
		
		#endregion
		
		
		#region "ClientsByEmailProvider"
			
		private SqlClientsByEmailProvider innerSqlClientsByEmailProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ClientsByEmail"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ClientsByEmailProviderBase ClientsByEmailProvider
		{
			get
			{
				if (innerSqlClientsByEmailProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlClientsByEmailProvider == null)
						{
							this.innerSqlClientsByEmailProvider = new SqlClientsByEmailProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlClientsByEmailProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlClientsByEmailProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlClientsByEmailProvider SqlClientsByEmailProvider
		{
			get {return ClientsByEmailProvider as SqlClientsByEmailProvider;}
		}
		
		#endregion
		
		
		#region "AdministratorsRolesProvider"
			
		private SqlAdministratorsRolesProvider innerSqlAdministratorsRolesProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="AdministratorsRoles"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override AdministratorsRolesProviderBase AdministratorsRolesProvider
		{
			get
			{
				if (innerSqlAdministratorsRolesProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlAdministratorsRolesProvider == null)
						{
							this.innerSqlAdministratorsRolesProvider = new SqlAdministratorsRolesProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlAdministratorsRolesProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlAdministratorsRolesProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlAdministratorsRolesProvider SqlAdministratorsRolesProvider
		{
			get {return AdministratorsRolesProvider as SqlAdministratorsRolesProvider;}
		}
		
		#endregion
		
		
		#region "AdministratorsRolesByAdministratorProvider"
			
		private SqlAdministratorsRolesByAdministratorProvider innerSqlAdministratorsRolesByAdministratorProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="AdministratorsRolesByAdministrator"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override AdministratorsRolesByAdministratorProviderBase AdministratorsRolesByAdministratorProvider
		{
			get
			{
				if (innerSqlAdministratorsRolesByAdministratorProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlAdministratorsRolesByAdministratorProvider == null)
						{
							this.innerSqlAdministratorsRolesByAdministratorProvider = new SqlAdministratorsRolesByAdministratorProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlAdministratorsRolesByAdministratorProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlAdministratorsRolesByAdministratorProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlAdministratorsRolesByAdministratorProvider SqlAdministratorsRolesByAdministratorProvider
		{
			get {return AdministratorsRolesByAdministratorProvider as SqlAdministratorsRolesByAdministratorProvider;}
		}
		
		#endregion
		
		
		#region "AdministratorsByEmailProvider"
			
		private SqlAdministratorsByEmailProvider innerSqlAdministratorsByEmailProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="AdministratorsByEmail"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override AdministratorsByEmailProviderBase AdministratorsByEmailProvider
		{
			get
			{
				if (innerSqlAdministratorsByEmailProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlAdministratorsByEmailProvider == null)
						{
							this.innerSqlAdministratorsByEmailProvider = new SqlAdministratorsByEmailProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlAdministratorsByEmailProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlAdministratorsByEmailProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlAdministratorsByEmailProvider SqlAdministratorsByEmailProvider
		{
			get {return AdministratorsByEmailProvider as SqlAdministratorsByEmailProvider;}
		}
		
		#endregion
		
		
		#region "AdministratorsByDepartmentsProvider"
			
		private SqlAdministratorsByDepartmentsProvider innerSqlAdministratorsByDepartmentsProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="AdministratorsByDepartments"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override AdministratorsByDepartmentsProviderBase AdministratorsByDepartmentsProvider
		{
			get
			{
				if (innerSqlAdministratorsByDepartmentsProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlAdministratorsByDepartmentsProvider == null)
						{
							this.innerSqlAdministratorsByDepartmentsProvider = new SqlAdministratorsByDepartmentsProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlAdministratorsByDepartmentsProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlAdministratorsByDepartmentsProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlAdministratorsByDepartmentsProvider SqlAdministratorsByDepartmentsProvider
		{
			get {return AdministratorsByDepartmentsProvider as SqlAdministratorsByDepartmentsProvider;}
		}
		
		#endregion
		
		
		#region "BusRoutesProvider"
			
		private SqlBusRoutesProvider innerSqlBusRoutesProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="BusRoutes"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override BusRoutesProviderBase BusRoutesProvider
		{
			get
			{
				if (innerSqlBusRoutesProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlBusRoutesProvider == null)
						{
							this.innerSqlBusRoutesProvider = new SqlBusRoutesProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlBusRoutesProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlBusRoutesProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlBusRoutesProvider SqlBusRoutesProvider
		{
			get {return BusRoutesProvider as SqlBusRoutesProvider;}
		}
		
		#endregion
		
		
		#region "BusRoutesDetailsProvider"
			
		private SqlBusRoutesDetailsProvider innerSqlBusRoutesDetailsProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="BusRoutesDetails"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override BusRoutesDetailsProviderBase BusRoutesDetailsProvider
		{
			get
			{
				if (innerSqlBusRoutesDetailsProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlBusRoutesDetailsProvider == null)
						{
							this.innerSqlBusRoutesDetailsProvider = new SqlBusRoutesDetailsProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlBusRoutesDetailsProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlBusRoutesDetailsProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlBusRoutesDetailsProvider SqlBusRoutesDetailsProvider
		{
			get {return BusRoutesDetailsProvider as SqlBusRoutesDetailsProvider;}
		}
		
		#endregion
		
		
		#region "ClientsByClientsGroupsProvider"
			
		private SqlClientsByClientsGroupsProvider innerSqlClientsByClientsGroupsProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ClientsByClientsGroups"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ClientsByClientsGroupsProviderBase ClientsByClientsGroupsProvider
		{
			get
			{
				if (innerSqlClientsByClientsGroupsProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlClientsByClientsGroupsProvider == null)
						{
							this.innerSqlClientsByClientsGroupsProvider = new SqlClientsByClientsGroupsProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlClientsByClientsGroupsProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlClientsByClientsGroupsProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlClientsByClientsGroupsProvider SqlClientsByClientsGroupsProvider
		{
			get {return ClientsByClientsGroupsProvider as SqlClientsByClientsGroupsProvider;}
		}
		
		#endregion
		
		
		#region "CatalogStatisticsProvider"
			
		private SqlCatalogStatisticsProvider innerSqlCatalogStatisticsProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="CatalogStatistics"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override CatalogStatisticsProviderBase CatalogStatisticsProvider
		{
			get
			{
				if (innerSqlCatalogStatisticsProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlCatalogStatisticsProvider == null)
						{
							this.innerSqlCatalogStatisticsProvider = new SqlCatalogStatisticsProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlCatalogStatisticsProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlCatalogStatisticsProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlCatalogStatisticsProvider SqlCatalogStatisticsProvider
		{
			get {return CatalogStatisticsProvider as SqlCatalogStatisticsProvider;}
		}
		
		#endregion
		
		
		#region "BusStopProvider"
			
		private SqlBusStopProvider innerSqlBusStopProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="BusStop"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override BusStopProviderBase BusStopProvider
		{
			get
			{
				if (innerSqlBusStopProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlBusStopProvider == null)
						{
							this.innerSqlBusStopProvider = new SqlBusStopProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlBusStopProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlBusStopProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlBusStopProvider SqlBusStopProvider
		{
			get {return BusStopProvider as SqlBusStopProvider;}
		}
		
		#endregion
		
		
		#region "BusRouteByGpsGroupsProvider"
			
		private SqlBusRouteByGpsGroupsProvider innerSqlBusRouteByGpsGroupsProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="BusRouteByGpsGroups"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override BusRouteByGpsGroupsProviderBase BusRouteByGpsGroupsProvider
		{
			get
			{
				if (innerSqlBusRouteByGpsGroupsProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlBusRouteByGpsGroupsProvider == null)
						{
							this.innerSqlBusRouteByGpsGroupsProvider = new SqlBusRouteByGpsGroupsProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlBusRouteByGpsGroupsProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlBusRouteByGpsGroupsProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlBusRouteByGpsGroupsProvider SqlBusRouteByGpsGroupsProvider
		{
			get {return BusRouteByGpsGroupsProvider as SqlBusRouteByGpsGroupsProvider;}
		}
		
		#endregion
		
		
		#region "BusStopByBusRoutesProvider"
			
		private SqlBusStopByBusRoutesProvider innerSqlBusStopByBusRoutesProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="BusStopByBusRoutes"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override BusStopByBusRoutesProviderBase BusStopByBusRoutesProvider
		{
			get
			{
				if (innerSqlBusStopByBusRoutesProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlBusStopByBusRoutesProvider == null)
						{
							this.innerSqlBusStopByBusRoutesProvider = new SqlBusStopByBusRoutesProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlBusStopByBusRoutesProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlBusStopByBusRoutesProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlBusStopByBusRoutesProvider SqlBusStopByBusRoutesProvider
		{
			get {return BusStopByBusRoutesProvider as SqlBusStopByBusRoutesProvider;}
		}
		
		#endregion
		
		
		#region "CompaniesBySettingProvider"
			
		private SqlCompaniesBySettingProvider innerSqlCompaniesBySettingProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="CompaniesBySetting"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override CompaniesBySettingProviderBase CompaniesBySettingProvider
		{
			get
			{
				if (innerSqlCompaniesBySettingProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlCompaniesBySettingProvider == null)
						{
							this.innerSqlCompaniesBySettingProvider = new SqlCompaniesBySettingProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlCompaniesBySettingProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlCompaniesBySettingProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlCompaniesBySettingProvider SqlCompaniesBySettingProvider
		{
			get {return CompaniesBySettingProvider as SqlCompaniesBySettingProvider;}
		}
		
		#endregion
		
		
		#region "BusRouteByCompaniesProvider"
			
		private SqlBusRouteByCompaniesProvider innerSqlBusRouteByCompaniesProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="BusRouteByCompanies"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override BusRouteByCompaniesProviderBase BusRouteByCompaniesProvider
		{
			get
			{
				if (innerSqlBusRouteByCompaniesProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlBusRouteByCompaniesProvider == null)
						{
							this.innerSqlBusRouteByCompaniesProvider = new SqlBusRouteByCompaniesProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlBusRouteByCompaniesProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlBusRouteByCompaniesProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlBusRouteByCompaniesProvider SqlBusRouteByCompaniesProvider
		{
			get {return BusRouteByCompaniesProvider as SqlBusRouteByCompaniesProvider;}
		}
		
		#endregion
		
		
		#region "MastersRolesByMasterProvider"
			
		private SqlMastersRolesByMasterProvider innerSqlMastersRolesByMasterProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="MastersRolesByMaster"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override MastersRolesByMasterProviderBase MastersRolesByMasterProvider
		{
			get
			{
				if (innerSqlMastersRolesByMasterProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlMastersRolesByMasterProvider == null)
						{
							this.innerSqlMastersRolesByMasterProvider = new SqlMastersRolesByMasterProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlMastersRolesByMasterProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlMastersRolesByMasterProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlMastersRolesByMasterProvider SqlMastersRolesByMasterProvider
		{
			get {return MastersRolesByMasterProvider as SqlMastersRolesByMasterProvider;}
		}
		
		#endregion
		
		
		#region "MenuTypesProvider"
			
		private SqlMenuTypesProvider innerSqlMenuTypesProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="MenuTypes"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override MenuTypesProviderBase MenuTypesProvider
		{
			get
			{
				if (innerSqlMenuTypesProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlMenuTypesProvider == null)
						{
							this.innerSqlMenuTypesProvider = new SqlMenuTypesProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlMenuTypesProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlMenuTypesProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlMenuTypesProvider SqlMenuTypesProvider
		{
			get {return MenuTypesProvider as SqlMenuTypesProvider;}
		}
		
		#endregion
		
		
		#region "MastersProvider"
			
		private SqlMastersProvider innerSqlMastersProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Masters"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override MastersProviderBase MastersProvider
		{
			get
			{
				if (innerSqlMastersProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlMastersProvider == null)
						{
							this.innerSqlMastersProvider = new SqlMastersProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlMastersProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlMastersProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlMastersProvider SqlMastersProvider
		{
			get {return MastersProvider as SqlMastersProvider;}
		}
		
		#endregion
		
		
		#region "DayNamesProvider"
			
		private SqlDayNamesProvider innerSqlDayNamesProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="DayNames"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override DayNamesProviderBase DayNamesProvider
		{
			get
			{
				if (innerSqlDayNamesProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlDayNamesProvider == null)
						{
							this.innerSqlDayNamesProvider = new SqlDayNamesProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlDayNamesProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlDayNamesProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlDayNamesProvider SqlDayNamesProvider
		{
			get {return DayNamesProvider as SqlDayNamesProvider;}
		}
		
		#endregion
		
		
		#region "MasterRolesProvider"
			
		private SqlMasterRolesProvider innerSqlMasterRolesProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="MasterRoles"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override MasterRolesProviderBase MasterRolesProvider
		{
			get
			{
				if (innerSqlMasterRolesProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlMasterRolesProvider == null)
						{
							this.innerSqlMasterRolesProvider = new SqlMasterRolesProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlMasterRolesProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlMasterRolesProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlMasterRolesProvider SqlMasterRolesProvider
		{
			get {return MasterRolesProvider as SqlMasterRolesProvider;}
		}
		
		#endregion
		
		
		#region "MenuProvider"
			
		private SqlMenuProvider innerSqlMenuProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Menu"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override MenuProviderBase MenuProvider
		{
			get
			{
				if (innerSqlMenuProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlMenuProvider == null)
						{
							this.innerSqlMenuProvider = new SqlMenuProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlMenuProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlMenuProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlMenuProvider SqlMenuProvider
		{
			get {return MenuProvider as SqlMenuProvider;}
		}
		
		#endregion
		
		
		#region "LogProvider"
			
		private SqlLogProvider innerSqlLogProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Log"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override LogProviderBase LogProvider
		{
			get
			{
				if (innerSqlLogProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlLogProvider == null)
						{
							this.innerSqlLogProvider = new SqlLogProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlLogProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlLogProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlLogProvider SqlLogProvider
		{
			get {return LogProvider as SqlLogProvider;}
		}
		
		#endregion
		
		
		#region "GpsTypeProvider"
			
		private SqlGpsTypeProvider innerSqlGpsTypeProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="GpsType"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override GpsTypeProviderBase GpsTypeProvider
		{
			get
			{
				if (innerSqlGpsTypeProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlGpsTypeProvider == null)
						{
							this.innerSqlGpsTypeProvider = new SqlGpsTypeProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlGpsTypeProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlGpsTypeProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlGpsTypeProvider SqlGpsTypeProvider
		{
			get {return GpsTypeProvider as SqlGpsTypeProvider;}
		}
		
		#endregion
		
		
		#region "MenuByAdministratorRolesProvider"
			
		private SqlMenuByAdministratorRolesProvider innerSqlMenuByAdministratorRolesProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="MenuByAdministratorRoles"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override MenuByAdministratorRolesProviderBase MenuByAdministratorRolesProvider
		{
			get
			{
				if (innerSqlMenuByAdministratorRolesProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlMenuByAdministratorRolesProvider == null)
						{
							this.innerSqlMenuByAdministratorRolesProvider = new SqlMenuByAdministratorRolesProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlMenuByAdministratorRolesProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlMenuByAdministratorRolesProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlMenuByAdministratorRolesProvider SqlMenuByAdministratorRolesProvider
		{
			get {return MenuByAdministratorRolesProvider as SqlMenuByAdministratorRolesProvider;}
		}
		
		#endregion
		
		
		#region "NotificationsByCompaniesProvider"
			
		private SqlNotificationsByCompaniesProvider innerSqlNotificationsByCompaniesProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="NotificationsByCompanies"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override NotificationsByCompaniesProviderBase NotificationsByCompaniesProvider
		{
			get
			{
				if (innerSqlNotificationsByCompaniesProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlNotificationsByCompaniesProvider == null)
						{
							this.innerSqlNotificationsByCompaniesProvider = new SqlNotificationsByCompaniesProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlNotificationsByCompaniesProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlNotificationsByCompaniesProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlNotificationsByCompaniesProvider SqlNotificationsByCompaniesProvider
		{
			get {return NotificationsByCompaniesProvider as SqlNotificationsByCompaniesProvider;}
		}
		
		#endregion
		
		
		#region "MessageQueueLogProvider"
			
		private SqlMessageQueueLogProvider innerSqlMessageQueueLogProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="MessageQueueLog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override MessageQueueLogProviderBase MessageQueueLogProvider
		{
			get
			{
				if (innerSqlMessageQueueLogProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlMessageQueueLogProvider == null)
						{
							this.innerSqlMessageQueueLogProvider = new SqlMessageQueueLogProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlMessageQueueLogProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlMessageQueueLogProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlMessageQueueLogProvider SqlMessageQueueLogProvider
		{
			get {return MessageQueueLogProvider as SqlMessageQueueLogProvider;}
		}
		
		#endregion
		
		
		#region "MenuByUserRolesProvider"
			
		private SqlMenuByUserRolesProvider innerSqlMenuByUserRolesProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="MenuByUserRoles"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override MenuByUserRolesProviderBase MenuByUserRolesProvider
		{
			get
			{
				if (innerSqlMenuByUserRolesProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlMenuByUserRolesProvider == null)
						{
							this.innerSqlMenuByUserRolesProvider = new SqlMenuByUserRolesProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlMenuByUserRolesProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlMenuByUserRolesProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlMenuByUserRolesProvider SqlMenuByUserRolesProvider
		{
			get {return MenuByUserRolesProvider as SqlMenuByUserRolesProvider;}
		}
		
		#endregion
		
		
		#region "MenuByMasterRolesProvider"
			
		private SqlMenuByMasterRolesProvider innerSqlMenuByMasterRolesProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="MenuByMasterRoles"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override MenuByMasterRolesProviderBase MenuByMasterRolesProvider
		{
			get
			{
				if (innerSqlMenuByMasterRolesProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlMenuByMasterRolesProvider == null)
						{
							this.innerSqlMenuByMasterRolesProvider = new SqlMenuByMasterRolesProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlMenuByMasterRolesProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlMenuByMasterRolesProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlMenuByMasterRolesProvider SqlMenuByMasterRolesProvider
		{
			get {return MenuByMasterRolesProvider as SqlMenuByMasterRolesProvider;}
		}
		
		#endregion
		
		
		#region "GpsModelsProvider"
			
		private SqlGpsModelsProvider innerSqlGpsModelsProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="GpsModels"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override GpsModelsProviderBase GpsModelsProvider
		{
			get
			{
				if (innerSqlGpsModelsProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlGpsModelsProvider == null)
						{
							this.innerSqlGpsModelsProvider = new SqlGpsModelsProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlGpsModelsProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlGpsModelsProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlGpsModelsProvider SqlGpsModelsProvider
		{
			get {return GpsModelsProvider as SqlGpsModelsProvider;}
		}
		
		#endregion
		
		
		#region "GpsStockProvider"
			
		private SqlGpsStockProvider innerSqlGpsStockProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="GpsStock"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override GpsStockProviderBase GpsStockProvider
		{
			get
			{
				if (innerSqlGpsStockProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlGpsStockProvider == null)
						{
							this.innerSqlGpsStockProvider = new SqlGpsStockProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlGpsStockProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlGpsStockProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlGpsStockProvider SqlGpsStockProvider
		{
			get {return GpsStockProvider as SqlGpsStockProvider;}
		}
		
		#endregion
		
		
		#region "GpsStockByGpsGroupsProvider"
			
		private SqlGpsStockByGpsGroupsProvider innerSqlGpsStockByGpsGroupsProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="GpsStockByGpsGroups"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override GpsStockByGpsGroupsProviderBase GpsStockByGpsGroupsProvider
		{
			get
			{
				if (innerSqlGpsStockByGpsGroupsProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlGpsStockByGpsGroupsProvider == null)
						{
							this.innerSqlGpsStockByGpsGroupsProvider = new SqlGpsStockByGpsGroupsProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlGpsStockByGpsGroupsProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlGpsStockByGpsGroupsProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlGpsStockByGpsGroupsProvider SqlGpsStockByGpsGroupsProvider
		{
			get {return GpsStockByGpsGroupsProvider as SqlGpsStockByGpsGroupsProvider;}
		}
		
		#endregion
		
		
		#region "EmailToSendStocksProvider"
			
		private SqlEmailToSendStocksProvider innerSqlEmailToSendStocksProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="EmailToSendStocks"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override EmailToSendStocksProviderBase EmailToSendStocksProvider
		{
			get
			{
				if (innerSqlEmailToSendStocksProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlEmailToSendStocksProvider == null)
						{
							this.innerSqlEmailToSendStocksProvider = new SqlEmailToSendStocksProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlEmailToSendStocksProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlEmailToSendStocksProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlEmailToSendStocksProvider SqlEmailToSendStocksProvider
		{
			get {return EmailToSendStocksProvider as SqlEmailToSendStocksProvider;}
		}
		
		#endregion
		
		
		#region "EmailToSendStockByClientsProvider"
			
		private SqlEmailToSendStockByClientsProvider innerSqlEmailToSendStockByClientsProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="EmailToSendStockByClients"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override EmailToSendStockByClientsProviderBase EmailToSendStockByClientsProvider
		{
			get
			{
				if (innerSqlEmailToSendStockByClientsProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlEmailToSendStockByClientsProvider == null)
						{
							this.innerSqlEmailToSendStockByClientsProvider = new SqlEmailToSendStockByClientsProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlEmailToSendStockByClientsProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlEmailToSendStockByClientsProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlEmailToSendStockByClientsProvider SqlEmailToSendStockByClientsProvider
		{
			get {return EmailToSendStockByClientsProvider as SqlEmailToSendStockByClientsProvider;}
		}
		
		#endregion
		
		
		#region "DriversProvider"
			
		private SqlDriversProvider innerSqlDriversProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Drivers"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override DriversProviderBase DriversProvider
		{
			get
			{
				if (innerSqlDriversProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlDriversProvider == null)
						{
							this.innerSqlDriversProvider = new SqlDriversProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlDriversProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlDriversProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlDriversProvider SqlDriversProvider
		{
			get {return DriversProvider as SqlDriversProvider;}
		}
		
		#endregion
		
		
		#region "DepartmentsProvider"
			
		private SqlDepartmentsProvider innerSqlDepartmentsProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Departments"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override DepartmentsProviderBase DepartmentsProvider
		{
			get
			{
				if (innerSqlDepartmentsProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlDepartmentsProvider == null)
						{
							this.innerSqlDepartmentsProvider = new SqlDepartmentsProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlDepartmentsProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlDepartmentsProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlDepartmentsProvider SqlDepartmentsProvider
		{
			get {return DepartmentsProvider as SqlDepartmentsProvider;}
		}
		
		#endregion
		
		
		#region "DriversByCompaniesProvider"
			
		private SqlDriversByCompaniesProvider innerSqlDriversByCompaniesProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="DriversByCompanies"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override DriversByCompaniesProviderBase DriversByCompaniesProvider
		{
			get
			{
				if (innerSqlDriversByCompaniesProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlDriversByCompaniesProvider == null)
						{
							this.innerSqlDriversByCompaniesProvider = new SqlDriversByCompaniesProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlDriversByCompaniesProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlDriversByCompaniesProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlDriversByCompaniesProvider SqlDriversByCompaniesProvider
		{
			get {return DriversByCompaniesProvider as SqlDriversByCompaniesProvider;}
		}
		
		#endregion
		
		
		#region "EmailToSendStockByStockFilesProvider"
			
		private SqlEmailToSendStockByStockFilesProvider innerSqlEmailToSendStockByStockFilesProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="EmailToSendStockByStockFiles"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override EmailToSendStockByStockFilesProviderBase EmailToSendStockByStockFilesProvider
		{
			get
			{
				if (innerSqlEmailToSendStockByStockFilesProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlEmailToSendStockByStockFilesProvider == null)
						{
							this.innerSqlEmailToSendStockByStockFilesProvider = new SqlEmailToSendStockByStockFilesProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlEmailToSendStockByStockFilesProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlEmailToSendStockByStockFilesProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlEmailToSendStockByStockFilesProvider SqlEmailToSendStockByStockFilesProvider
		{
			get {return EmailToSendStockByStockFilesProvider as SqlEmailToSendStockByStockFilesProvider;}
		}
		
		#endregion
		
		
		#region "NotificationByGeoFencesByGpsStockProvider"
			
		private SqlNotificationByGeoFencesByGpsStockProvider innerSqlNotificationByGeoFencesByGpsStockProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="NotificationByGeoFencesByGpsStock"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override NotificationByGeoFencesByGpsStockProviderBase NotificationByGeoFencesByGpsStockProvider
		{
			get
			{
				if (innerSqlNotificationByGeoFencesByGpsStockProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlNotificationByGeoFencesByGpsStockProvider == null)
						{
							this.innerSqlNotificationByGeoFencesByGpsStockProvider = new SqlNotificationByGeoFencesByGpsStockProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlNotificationByGeoFencesByGpsStockProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlNotificationByGeoFencesByGpsStockProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlNotificationByGeoFencesByGpsStockProvider SqlNotificationByGeoFencesByGpsStockProvider
		{
			get {return NotificationByGeoFencesByGpsStockProvider as SqlNotificationByGeoFencesByGpsStockProvider;}
		}
		
		#endregion
		
		
		#region "GeoFencesProvider"
			
		private SqlGeoFencesProvider innerSqlGeoFencesProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="GeoFences"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override GeoFencesProviderBase GeoFencesProvider
		{
			get
			{
				if (innerSqlGeoFencesProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlGeoFencesProvider == null)
						{
							this.innerSqlGeoFencesProvider = new SqlGeoFencesProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlGeoFencesProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlGeoFencesProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlGeoFencesProvider SqlGeoFencesProvider
		{
			get {return GeoFencesProvider as SqlGeoFencesProvider;}
		}
		
		#endregion
		
		
		#region "EmailToSendStockByStocksProvider"
			
		private SqlEmailToSendStockByStocksProvider innerSqlEmailToSendStockByStocksProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="EmailToSendStockByStocks"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override EmailToSendStockByStocksProviderBase EmailToSendStockByStocksProvider
		{
			get
			{
				if (innerSqlEmailToSendStockByStocksProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlEmailToSendStockByStocksProvider == null)
						{
							this.innerSqlEmailToSendStockByStocksProvider = new SqlEmailToSendStockByStocksProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlEmailToSendStockByStocksProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlEmailToSendStockByStocksProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlEmailToSendStockByStocksProvider SqlEmailToSendStockByStocksProvider
		{
			get {return EmailToSendStockByStocksProvider as SqlEmailToSendStockByStocksProvider;}
		}
		
		#endregion
		
		
		#region "GpsCommandsProvider"
			
		private SqlGpsCommandsProvider innerSqlGpsCommandsProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="GpsCommands"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override GpsCommandsProviderBase GpsCommandsProvider
		{
			get
			{
				if (innerSqlGpsCommandsProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlGpsCommandsProvider == null)
						{
							this.innerSqlGpsCommandsProvider = new SqlGpsCommandsProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlGpsCommandsProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlGpsCommandsProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlGpsCommandsProvider SqlGpsCommandsProvider
		{
			get {return GpsCommandsProvider as SqlGpsCommandsProvider;}
		}
		
		#endregion
		
		
		#region "GpsGroupsProvider"
			
		private SqlGpsGroupsProvider innerSqlGpsGroupsProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="GpsGroups"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override GpsGroupsProviderBase GpsGroupsProvider
		{
			get
			{
				if (innerSqlGpsGroupsProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlGpsGroupsProvider == null)
						{
							this.innerSqlGpsGroupsProvider = new SqlGpsGroupsProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlGpsGroupsProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlGpsGroupsProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlGpsGroupsProvider SqlGpsGroupsProvider
		{
			get {return GpsGroupsProvider as SqlGpsGroupsProvider;}
		}
		
		#endregion
		
		
		#region "GeoFencesByGpsStockProvider"
			
		private SqlGeoFencesByGpsStockProvider innerSqlGeoFencesByGpsStockProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="GeoFencesByGpsStock"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override GeoFencesByGpsStockProviderBase GeoFencesByGpsStockProvider
		{
			get
			{
				if (innerSqlGeoFencesByGpsStockProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlGeoFencesByGpsStockProvider == null)
						{
							this.innerSqlGeoFencesByGpsStockProvider = new SqlGeoFencesByGpsStockProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlGeoFencesByGpsStockProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlGeoFencesByGpsStockProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlGeoFencesByGpsStockProvider SqlGeoFencesByGpsStockProvider
		{
			get {return GeoFencesByGpsStockProvider as SqlGeoFencesByGpsStockProvider;}
		}
		
		#endregion
		
		
		#region "GeoFenceDetailsProvider"
			
		private SqlGeoFenceDetailsProvider innerSqlGeoFenceDetailsProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="GeoFenceDetails"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override GeoFenceDetailsProviderBase GeoFenceDetailsProvider
		{
			get
			{
				if (innerSqlGeoFenceDetailsProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlGeoFenceDetailsProvider == null)
						{
							this.innerSqlGeoFenceDetailsProvider = new SqlGeoFenceDetailsProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlGeoFenceDetailsProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlGeoFenceDetailsProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlGeoFenceDetailsProvider SqlGeoFenceDetailsProvider
		{
			get {return GeoFenceDetailsProvider as SqlGeoFenceDetailsProvider;}
		}
		
		#endregion
		
		
		#region "WorkTimeProvider"
			
		private SqlWorkTimeProvider innerSqlWorkTimeProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="WorkTime"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override WorkTimeProviderBase WorkTimeProvider
		{
			get
			{
				if (innerSqlWorkTimeProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlWorkTimeProvider == null)
						{
							this.innerSqlWorkTimeProvider = new SqlWorkTimeProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlWorkTimeProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <see cref="SqlWorkTimeProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlWorkTimeProvider SqlWorkTimeProvider
		{
			get {return WorkTimeProvider as SqlWorkTimeProvider;}
		}
		
		#endregion
		
		
		
		#region "General data access methods"

		#region "ExecuteNonQuery"
		/// <summary>
		/// Executes the non query.
		/// </summary>
		/// <param name="storedProcedureName">Name of the stored procedure.</param>
		/// <param name="parameterValues">The parameter values.</param>
		/// <returns></returns>
		public override int ExecuteNonQuery(string storedProcedureName, params object[] parameterValues)
		{
			SqlDatabase database = new SqlDatabase(this._connectionString);
			return database.ExecuteNonQuery(storedProcedureName, parameterValues);	
		}

		/// <summary>
		/// Executes the non query.
		/// </summary>
		/// <param name="transactionManager">The transaction manager.</param>
		/// <param name="storedProcedureName">Name of the stored procedure.</param>
		/// <param name="parameterValues">The parameter values.</param>
		/// <returns></returns>
		public override int ExecuteNonQuery(TransactionManager transactionManager, string storedProcedureName, params object[] parameterValues)
		{
			SqlDatabase database = new SqlDatabase(this._connectionString);
			return database.ExecuteNonQuery(transactionManager.TransactionObject, storedProcedureName, parameterValues);	
		}

		/// <summary>
		/// Executes the non query.
		/// </summary>
		/// <param name="commandWrapper">The command wrapper.</param>
		public override void ExecuteNonQuery(DbCommand commandWrapper)
		{
			SqlDatabase database = new SqlDatabase(this._connectionString);
			database.ExecuteNonQuery(commandWrapper);	
			
		}

		/// <summary>
		/// Executes the non query.
		/// </summary>
		/// <param name="transactionManager">The transaction manager.</param>
		/// <param name="commandWrapper">The command wrapper.</param>
		public override void ExecuteNonQuery(TransactionManager transactionManager, DbCommand commandWrapper)
		{
			SqlDatabase database = new SqlDatabase(this._connectionString);
			database.ExecuteNonQuery(commandWrapper, transactionManager.TransactionObject);	
		}


		/// <summary>
		/// Executes the non query.
		/// </summary>
		/// <param name="commandType">Type of the command.</param>
		/// <param name="commandText">The command text.</param>
		/// <returns></returns>
		public override int ExecuteNonQuery(CommandType commandType, string commandText)
		{
			SqlDatabase database = new SqlDatabase(this._connectionString);
			return database.ExecuteNonQuery(commandType, commandText);	
		}
		/// <summary>
		/// Executes the non query.
		/// </summary>
		/// <param name="transactionManager">The transaction manager.</param>
		/// <param name="commandType">Type of the command.</param>
		/// <param name="commandText">The command text.</param>
		/// <returns></returns>
		public override int ExecuteNonQuery(TransactionManager transactionManager, CommandType commandType, string commandText)
		{
			Database database = transactionManager.Database;			
			return database.ExecuteNonQuery(transactionManager.TransactionObject , commandType, commandText);				
		}
		#endregion

		#region "ExecuteDataReader"
		/// <summary>
		/// Executes the reader.
		/// </summary>
		/// <param name="storedProcedureName">Name of the stored procedure.</param>
		/// <param name="parameterValues">The parameter values.</param>
		/// <returns></returns>
		public override IDataReader ExecuteReader(string storedProcedureName, params object[] parameterValues)
		{
			SqlDatabase database = new SqlDatabase(this._connectionString);			
			return database.ExecuteReader(storedProcedureName, parameterValues);	
		}

		/// <summary>
		/// Executes the reader.
		/// </summary>
		/// <param name="transactionManager">The transaction manager.</param>
		/// <param name="storedProcedureName">Name of the stored procedure.</param>
		/// <param name="parameterValues">The parameter values.</param>
		/// <returns></returns>
		public override IDataReader ExecuteReader(TransactionManager transactionManager, string storedProcedureName, params object[] parameterValues)
		{
			Database database = transactionManager.Database;
			return database.ExecuteReader(transactionManager.TransactionObject, storedProcedureName, parameterValues);	
		}

		/// <summary>
		/// Executes the reader.
		/// </summary>
		/// <param name="commandWrapper">The command wrapper.</param>
		/// <returns></returns>
		public override IDataReader ExecuteReader(DbCommand commandWrapper)
		{
			SqlDatabase database = new SqlDatabase(this._connectionString);			
			return database.ExecuteReader(commandWrapper);	
		}

		/// <summary>
		/// Executes the reader.
		/// </summary>
		/// <param name="transactionManager">The transaction manager.</param>
		/// <param name="commandWrapper">The command wrapper.</param>
		/// <returns></returns>
		public override IDataReader ExecuteReader(TransactionManager transactionManager, DbCommand commandWrapper)
		{
			Database database = transactionManager.Database;
			return database.ExecuteReader(commandWrapper, transactionManager.TransactionObject);	
		}


		/// <summary>
		/// Executes the reader.
		/// </summary>
		/// <param name="commandType">Type of the command.</param>
		/// <param name="commandText">The command text.</param>
		/// <returns></returns>
		public override IDataReader ExecuteReader(CommandType commandType, string commandText)
		{
			SqlDatabase database = new SqlDatabase(this._connectionString);
			return database.ExecuteReader(commandType, commandText);	
		}
		/// <summary>
		/// Executes the reader.
		/// </summary>
		/// <param name="transactionManager">The transaction manager.</param>
		/// <param name="commandType">Type of the command.</param>
		/// <param name="commandText">The command text.</param>
		/// <returns></returns>
		public override IDataReader ExecuteReader(TransactionManager transactionManager, CommandType commandType, string commandText)
		{
			Database database = transactionManager.Database;			
			return database.ExecuteReader(transactionManager.TransactionObject , commandType, commandText);				
		}
		#endregion

		#region "ExecuteDataSet"
		/// <summary>
		/// Executes the data set.
		/// </summary>
		/// <param name="storedProcedureName">Name of the stored procedure.</param>
		/// <param name="parameterValues">The parameter values.</param>
		/// <returns></returns>
		public override DataSet ExecuteDataSet(string storedProcedureName, params object[] parameterValues)
		{
			SqlDatabase database = new SqlDatabase(this._connectionString);			
			return database.ExecuteDataSet(storedProcedureName, parameterValues);	
		}

		/// <summary>
		/// Executes the data set.
		/// </summary>
		/// <param name="transactionManager">The transaction manager.</param>
		/// <param name="storedProcedureName">Name of the stored procedure.</param>
		/// <param name="parameterValues">The parameter values.</param>
		/// <returns></returns>
		public override DataSet ExecuteDataSet(TransactionManager transactionManager, string storedProcedureName, params object[] parameterValues)
		{
			Database database = transactionManager.Database;
			return database.ExecuteDataSet(transactionManager.TransactionObject, storedProcedureName, parameterValues);	
		}

		/// <summary>
		/// Executes the data set.
		/// </summary>
		/// <param name="commandWrapper">The command wrapper.</param>
		/// <returns></returns>
		public override DataSet ExecuteDataSet(DbCommand commandWrapper)
		{
			SqlDatabase database = new SqlDatabase(this._connectionString);			
			return database.ExecuteDataSet(commandWrapper);	
		}

		/// <summary>
		/// Executes the data set.
		/// </summary>
		/// <param name="transactionManager">The transaction manager.</param>
		/// <param name="commandWrapper">The command wrapper.</param>
		/// <returns></returns>
		public override DataSet ExecuteDataSet(TransactionManager transactionManager, DbCommand commandWrapper)
		{
			Database database = transactionManager.Database;
			return database.ExecuteDataSet(commandWrapper, transactionManager.TransactionObject);	
		}


		/// <summary>
		/// Executes the data set.
		/// </summary>
		/// <param name="commandType">Type of the command.</param>
		/// <param name="commandText">The command text.</param>
		/// <returns></returns>
		public override DataSet ExecuteDataSet(CommandType commandType, string commandText)
		{
			SqlDatabase database = new SqlDatabase(this._connectionString);
			return database.ExecuteDataSet(commandType, commandText);	
		}
		/// <summary>
		/// Executes the data set.
		/// </summary>
		/// <param name="transactionManager">The transaction manager.</param>
		/// <param name="commandType">Type of the command.</param>
		/// <param name="commandText">The command text.</param>
		/// <returns></returns>
		public override DataSet ExecuteDataSet(TransactionManager transactionManager, CommandType commandType, string commandText)
		{
			Database database = transactionManager.Database;			
			return database.ExecuteDataSet(transactionManager.TransactionObject , commandType, commandText);				
		}
		#endregion

		#region "ExecuteScalar"
		/// <summary>
		/// Executes the scalar.
		/// </summary>
		/// <param name="storedProcedureName">Name of the stored procedure.</param>
		/// <param name="parameterValues">The parameter values.</param>
		/// <returns></returns>
		public override object ExecuteScalar(string storedProcedureName, params object[] parameterValues)
		{
			SqlDatabase database = new SqlDatabase(this._connectionString);			
			return database.ExecuteScalar(storedProcedureName, parameterValues);	
		}

		/// <summary>
		/// Executes the scalar.
		/// </summary>
		/// <param name="transactionManager">The transaction manager.</param>
		/// <param name="storedProcedureName">Name of the stored procedure.</param>
		/// <param name="parameterValues">The parameter values.</param>
		/// <returns></returns>
		public override object ExecuteScalar(TransactionManager transactionManager, string storedProcedureName, params object[] parameterValues)
		{
			Database database = transactionManager.Database;
			return database.ExecuteScalar(transactionManager.TransactionObject, storedProcedureName, parameterValues);	
		}

		/// <summary>
		/// Executes the scalar.
		/// </summary>
		/// <param name="commandWrapper">The command wrapper.</param>
		/// <returns></returns>
		public override object ExecuteScalar(DbCommand commandWrapper)
		{
			SqlDatabase database = new SqlDatabase(this._connectionString);			
			return database.ExecuteScalar(commandWrapper);	
		}

		/// <summary>
		/// Executes the scalar.
		/// </summary>
		/// <param name="transactionManager">The transaction manager.</param>
		/// <param name="commandWrapper">The command wrapper.</param>
		/// <returns></returns>
		public override object ExecuteScalar(TransactionManager transactionManager, DbCommand commandWrapper)
		{
			Database database = transactionManager.Database;
			return database.ExecuteScalar(commandWrapper, transactionManager.TransactionObject);	
		}

		/// <summary>
		/// Executes the scalar.
		/// </summary>
		/// <param name="commandType">Type of the command.</param>
		/// <param name="commandText">The command text.</param>
		/// <returns></returns>
		public override object ExecuteScalar(CommandType commandType, string commandText)
		{
			SqlDatabase database = new SqlDatabase(this._connectionString);
			return database.ExecuteScalar(commandType, commandText);	
		}
		/// <summary>
		/// Executes the scalar.
		/// </summary>
		/// <param name="transactionManager">The transaction manager.</param>
		/// <param name="commandType">Type of the command.</param>
		/// <param name="commandText">The command text.</param>
		/// <returns></returns>
		public override object ExecuteScalar(TransactionManager transactionManager, CommandType commandType, string commandText)
		{
			Database database = transactionManager.Database;			
			return database.ExecuteScalar(transactionManager.TransactionObject , commandType, commandText);				
		}
		#endregion

		#endregion


	}
}
